const tags = msg.tags; // 现在是一个数组
const values =  msg.payload; // Modbus返回的原始数据缓冲区

const packet = new Uint16Array(values).buffer;

const dataView = new DataView(packet);


// 确保tags和values存在
if (!tags || !values) return msg;

let valueIndex = 0;
const results = {};

for (let i = 0; i < tags.length; i++) {
    const tag = tags[i];
    const key = tag[3];
    const dataType = tag[6];
    
    try {
        let value;
        
        switch(dataType) {
            case 'bool':
                // 布尔类型，取最低位
                value = (values[valueIndex] & 0x01) === 0x01;
                valueIndex += 1;
                break;
                
            case 'uint16':
                // 无符号16位整数
                value = values[valueIndex];
                valueIndex += 1;
                break;
                
            case 'int32':
                // 有符号32位整数，需要两个寄存器
                if (valueIndex + 1 >= values.length) {
                    node.error(`Not enough data for int32 at index ${valueIndex}`);
                    continue;
                }
                value = dataView.getInt32(valueIndex * 2, true); // false表示大端序
                valueIndex += 2;
                break;
                
            case 'float32':
                // 32位浮点数，需要两个寄存器
                if (valueIndex + 1 >= values.length) {
                    node.error(`Not enough data for float32 at index ${valueIndex}`);
                    continue;
                }
                value = dataView.getFloat32(valueIndex * 2, true); // false表示大端序
                valueIndex += 2;
                break;
                
            default:
                node.warn(`Unknown data type: ${dataType} for tag ${key}`);
                value = values[valueIndex];
                valueIndex += 1;
        }
        
        // 存储处理后的值
        results[key] = value;
        global.set(key, value);
        
    } catch (err) {
        node.error(`Error processing tag ${key}: ${err}`);
    }
}

// 将处理结果附加到msg对象
msg.results = results;
return msg;